home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_strptime.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  19.8 KB  |  431 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''PyUnit testing against strptime'''
  5. import unittest
  6. import time
  7. import locale
  8. import re
  9. import sys
  10. from test import test_support
  11. from datetime import date as datetime_date
  12. import _strptime
  13.  
  14. class getlang_Tests(unittest.TestCase):
  15.     '''Test _getlang'''
  16.     
  17.     def test_basic(self):
  18.         self.failUnlessEqual(_strptime._getlang(), locale.getlocale(locale.LC_TIME))
  19.  
  20.  
  21.  
  22. class LocaleTime_Tests(unittest.TestCase):
  23.     '''Tests for _strptime.LocaleTime.
  24.  
  25.     All values are lower-cased when stored in LocaleTime, so make sure to
  26.     compare values after running ``lower`` on them.
  27.  
  28.     '''
  29.     
  30.     def setUp(self):
  31.         '''Create time tuple based on current time.'''
  32.         self.time_tuple = time.localtime()
  33.         self.LT_ins = _strptime.LocaleTime()
  34.  
  35.     
  36.     def compare_against_time(self, testing, directive, tuple_position, error_msg):
  37.         '''Helper method that tests testing against directive based on the
  38.         tuple_position of time_tuple.  Uses error_msg as error message.
  39.  
  40.         '''
  41.         strftime_output = time.strftime(directive, self.time_tuple).lower()
  42.         comparison = testing[self.time_tuple[tuple_position]]
  43.         self.failUnless(strftime_output in testing, '%s: not found in tuple' % error_msg)
  44.         self.failUnless(comparison == strftime_output, '%s: position within tuple incorrect; %s != %s' % (error_msg, comparison, strftime_output))
  45.  
  46.     
  47.     def test_weekday(self):
  48.         self.compare_against_time(self.LT_ins.f_weekday, '%A', 6, 'Testing of full weekday name failed')
  49.         self.compare_against_time(self.LT_ins.a_weekday, '%a', 6, 'Testing of abbreviated weekday name failed')
  50.  
  51.     
  52.     def test_month(self):
  53.         self.compare_against_time(self.LT_ins.f_month, '%B', 1, 'Testing against full month name failed')
  54.         self.compare_against_time(self.LT_ins.a_month, '%b', 1, 'Testing against abbreviated month name failed')
  55.  
  56.     
  57.     def test_am_pm(self):
  58.         strftime_output = time.strftime('%p', self.time_tuple).lower()
  59.         self.failUnless(strftime_output in self.LT_ins.am_pm, 'AM/PM representation not in tuple')
  60.         if self.time_tuple[3] < 12:
  61.             position = 0
  62.         else:
  63.             position = 1
  64.         self.failUnless(strftime_output == self.LT_ins.am_pm[position], 'AM/PM representation in the wrong position within the tuple')
  65.  
  66.     
  67.     def test_timezone(self):
  68.         timezone = time.strftime('%Z', self.time_tuple).lower()
  69.         if timezone:
  70.             if not timezone in self.LT_ins.timezone[0]:
  71.                 pass
  72.             self.failUnless(timezone in self.LT_ins.timezone[1], 'timezone %s not found in %s' % (timezone, self.LT_ins.timezone))
  73.         
  74.  
  75.     
  76.     def test_date_time(self):
  77.         magic_date = (1999, 3, 17, 22, 44, 55, 2, 76, 0)
  78.         strftime_output = time.strftime('%c', magic_date)
  79.         self.failUnless(strftime_output == time.strftime(self.LT_ins.LC_date_time, magic_date), 'LC_date_time incorrect')
  80.         strftime_output = time.strftime('%x', magic_date)
  81.         self.failUnless(strftime_output == time.strftime(self.LT_ins.LC_date, magic_date), 'LC_date incorrect')
  82.         strftime_output = time.strftime('%X', magic_date)
  83.         self.failUnless(strftime_output == time.strftime(self.LT_ins.LC_time, magic_date), 'LC_time incorrect')
  84.         LT = _strptime.LocaleTime()
  85.         LT.am_pm = ('', '')
  86.         self.failUnless(LT.LC_time, "LocaleTime's LC directives cannot handle empty strings")
  87.  
  88.     
  89.     def test_lang(self):
  90.         self.failUnlessEqual(self.LT_ins.lang, _strptime._getlang())
  91.  
  92.  
  93.  
  94. class TimeRETests(unittest.TestCase):
  95.     '''Tests for TimeRE.'''
  96.     
  97.     def setUp(self):
  98.         '''Construct generic TimeRE object.'''
  99.         self.time_re = _strptime.TimeRE()
  100.         self.locale_time = _strptime.LocaleTime()
  101.  
  102.     
  103.     def test_pattern(self):
  104.         pattern_string = self.time_re.pattern('%a %A %d')
  105.         self.failUnless(pattern_string.find(self.locale_time.a_weekday[2]) != -1, "did not find abbreviated weekday in pattern string '%s'" % pattern_string)
  106.         self.failUnless(pattern_string.find(self.locale_time.f_weekday[4]) != -1, "did not find full weekday in pattern string '%s'" % pattern_string)
  107.         self.failUnless(pattern_string.find(self.time_re['d']) != -1, "did not find 'd' directive pattern string '%s'" % pattern_string)
  108.  
  109.     
  110.     def test_pattern_escaping(self):
  111.         pattern_string = self.time_re.pattern('\\d+')
  112.         self.failUnless('\\\\d\\+' in pattern_string, '%s does not have re characters escaped properly' % pattern_string)
  113.  
  114.     
  115.     def test_compile(self):
  116.         found = self.time_re.compile('%A').match(self.locale_time.f_weekday[6])
  117.         if found:
  118.             pass
  119.         self.failUnless(found.group('A') == self.locale_time.f_weekday[6], "re object for '%A' failed")
  120.         compiled = self.time_re.compile('%a %b')
  121.         found = compiled.match('%s %s' % (self.locale_time.a_weekday[4], self.locale_time.a_month[4]))
  122.         self.failUnless(found, "Match failed with '%s' regex and '%s' string" % (compiled.pattern, '%s %s' % (self.locale_time.a_weekday[4], self.locale_time.a_month[4])))
  123.         if found.group('a') == self.locale_time.a_weekday[4]:
  124.             pass
  125.         self.failUnless(found.group('b') == self.locale_time.a_month[4], "re object couldn't find the abbreviated weekday month in '%s' using '%s'; group 'a' = '%s', group 'b' = %s'" % (found.string, found.re.pattern, found.group('a'), found.group('b')))
  126.         for directive in ('a', 'A', 'b', 'B', 'c', 'd', 'H', 'I', 'j', 'm', 'M', 'p', 'S', 'U', 'w', 'W', 'x', 'X', 'y', 'Y', 'Z', '%'):
  127.             compiled = self.time_re.compile('%' + directive)
  128.             found = compiled.match(time.strftime('%' + directive))
  129.             self.failUnless(found, "Matching failed on '%s' using '%s' regex" % (time.strftime('%' + directive), compiled.pattern))
  130.         
  131.  
  132.     
  133.     def test_blankpattern(self):
  134.         test_locale = _strptime.LocaleTime()
  135.         test_locale.timezone = (frozenset(), frozenset())
  136.         self.failUnless(_strptime.TimeRE(test_locale).pattern('%Z') == '', "with timezone == ('',''), TimeRE().pattern('%Z') != ''")
  137.  
  138.     
  139.     def test_matching_with_escapes(self):
  140.         compiled_re = self.time_re.compile('\\w+ %m')
  141.         found = compiled_re.match('\\w+ 10')
  142.         self.failUnless(found, "Escaping failed of format '\\w+ 10'")
  143.  
  144.     
  145.     def test_locale_data_w_regex_metacharacters(self):
  146.         locale_time = _strptime.LocaleTime()
  147.         locale_time.timezone = (frozenset(('utc', 'gmt', 'Tokyo (standard time)')), frozenset('Tokyo (daylight time)'))
  148.         time_re = _strptime.TimeRE(locale_time)
  149.         self.failUnless(time_re.compile('%Z').match('Tokyo (standard time)'), 'locale data that contains regex metacharacters is not properly escaped')
  150.  
  151.  
  152.  
  153. class StrptimeTests(unittest.TestCase):
  154.     '''Tests for _strptime.strptime.'''
  155.     
  156.     def setUp(self):
  157.         '''Create testing time tuple.'''
  158.         self.time_tuple = time.gmtime()
  159.  
  160.     
  161.     def test_TypeError(self):
  162.         self.assertRaises(ValueError, _strptime.strptime, data_string = '%d', format = '%A')
  163.  
  164.     
  165.     def test_unconverteddata(self):
  166.         self.assertRaises(ValueError, _strptime.strptime, '10 12', '%m')
  167.  
  168.     
  169.     def helper(self, directive, position):
  170.         '''Helper fxn in testing.'''
  171.         strf_output = time.strftime('%' + directive, self.time_tuple)
  172.         strp_output = _strptime.strptime(strf_output, '%' + directive)
  173.         self.failUnless(strp_output[position] == self.time_tuple[position], "testing of '%s' directive failed; '%s' -> %s != %s" % (directive, strf_output, strp_output[position], self.time_tuple[position]))
  174.  
  175.     
  176.     def test_year(self):
  177.         for directive in ('y', 'Y'):
  178.             self.helper(directive, 0)
  179.         
  180.         for century, bounds in ((1900, ('69', '99')), (2000, ('00', '68'))):
  181.             for bound in bounds:
  182.                 strp_output = _strptime.strptime(bound, '%y')
  183.                 expected_result = century + int(bound)
  184.                 self.failUnless(strp_output[0] == expected_result, "'y' test failed; passed in '%s' and returned '%s'" % (bound, strp_output[0]))
  185.             
  186.         
  187.  
  188.     
  189.     def test_month(self):
  190.         for directive in ('B', 'b', 'm'):
  191.             self.helper(directive, 1)
  192.         
  193.  
  194.     
  195.     def test_day(self):
  196.         self.helper('d', 2)
  197.  
  198.     
  199.     def test_hour(self):
  200.         self.helper('H', 3)
  201.         strf_output = time.strftime('%I %p', self.time_tuple)
  202.         strp_output = _strptime.strptime(strf_output, '%I %p')
  203.         self.failUnless(strp_output[3] == self.time_tuple[3], "testing of '%%I %%p' directive failed; '%s' -> %s != %s" % (strf_output, strp_output[3], self.time_tuple[3]))
  204.  
  205.     
  206.     def test_minute(self):
  207.         self.helper('M', 4)
  208.  
  209.     
  210.     def test_second(self):
  211.         self.helper('S', 5)
  212.  
  213.     
  214.     def test_weekday(self):
  215.         for directive in ('A', 'a', 'w'):
  216.             self.helper(directive, 6)
  217.         
  218.  
  219.     
  220.     def test_julian(self):
  221.         self.helper('j', 7)
  222.  
  223.     
  224.     def test_timezone(self):
  225.         strp_output = _strptime.strptime('UTC', '%Z')
  226.         self.failUnlessEqual(strp_output.tm_isdst, 0)
  227.         strp_output = _strptime.strptime('GMT', '%Z')
  228.         self.failUnlessEqual(strp_output.tm_isdst, 0)
  229.         if sys.platform == 'mac':
  230.             return None
  231.         
  232.         time_tuple = time.localtime()
  233.         strf_output = time.strftime('%Z')
  234.         strp_output = _strptime.strptime(strf_output, '%Z')
  235.         locale_time = _strptime.LocaleTime()
  236.         if time.tzname[0] != time.tzname[1] or not (time.daylight):
  237.             self.failUnless(strp_output[8] == time_tuple[8], "timezone check failed; '%s' -> %s != %s" % (strf_output, strp_output[8], time_tuple[8]))
  238.         else:
  239.             self.failUnless(strp_output[8] == -1, 'LocaleTime().timezone has duplicate values and time.daylight but timezone value not set to -1')
  240.  
  241.     
  242.     def test_bad_timezone(self):
  243.         if sys.platform == 'mac':
  244.             return None
  245.         
  246.         tz_name = time.tzname[0]
  247.         if tz_name.upper() in ('UTC', 'GMT'):
  248.             return None
  249.         
  250.         
  251.         try:
  252.             original_tzname = time.tzname
  253.             original_daylight = time.daylight
  254.             time.tzname = (tz_name, tz_name)
  255.             time.daylight = 1
  256.             tz_value = _strptime.strptime(tz_name, '%Z')[8]
  257.             self.failUnlessEqual(tz_value, -1, '%s lead to a timezone value of %s instead of -1 when time.daylight set to %s and passing in %s' % (time.tzname, tz_value, time.daylight, tz_name))
  258.         finally:
  259.             time.tzname = original_tzname
  260.             time.daylight = original_daylight
  261.  
  262.  
  263.     
  264.     def test_date_time(self):
  265.         for position in range(6):
  266.             self.helper('c', position)
  267.         
  268.  
  269.     
  270.     def test_date(self):
  271.         for position in range(0, 3):
  272.             self.helper('x', position)
  273.         
  274.  
  275.     
  276.     def test_time(self):
  277.         for position in range(3, 6):
  278.             self.helper('X', position)
  279.         
  280.  
  281.     
  282.     def test_percent(self):
  283.         strf_output = time.strftime('%m %% %Y', self.time_tuple)
  284.         strp_output = _strptime.strptime(strf_output, '%m %% %Y')
  285.         if strp_output[0] == self.time_tuple[0]:
  286.             pass
  287.         self.failUnless(strp_output[1] == self.time_tuple[1], 'handling of percent sign failed')
  288.  
  289.     
  290.     def test_caseinsensitive(self):
  291.         strf_output = time.strftime('%B', self.time_tuple)
  292.         self.failUnless(_strptime.strptime(strf_output.upper(), '%B'), 'strptime does not handle ALL-CAPS names properly')
  293.         self.failUnless(_strptime.strptime(strf_output.lower(), '%B'), 'strptime does not handle lowercase names properly')
  294.         self.failUnless(_strptime.strptime(strf_output.capitalize(), '%B'), 'strptime does not handle capword names properly')
  295.  
  296.     
  297.     def test_defaults(self):
  298.         defaults = (1900, 1, 1, 0, 0, 0, 0, 1, -1)
  299.         strp_output = _strptime.strptime('1', '%m')
  300.         self.failUnless(strp_output == defaults, 'Default values for strptime() are incorrect; %s != %s' % (strp_output, defaults))
  301.  
  302.     
  303.     def test_escaping(self):
  304.         need_escaping = '.^$*+?{}\\[]|)('
  305.         self.failUnless(_strptime.strptime(need_escaping, need_escaping))
  306.  
  307.  
  308.  
  309. class Strptime12AMPMTests(unittest.TestCase):
  310.     """Test a _strptime regression in '%I %p' at 12 noon (12 PM)"""
  311.     
  312.     def test_twelve_noon_midnight(self):
  313.         eq = self.assertEqual
  314.         eq(time.strptime('12 PM', '%I %p')[3], 12)
  315.         eq(time.strptime('12 AM', '%I %p')[3], 0)
  316.         eq(_strptime.strptime('12 PM', '%I %p')[3], 12)
  317.         eq(_strptime.strptime('12 AM', '%I %p')[3], 0)
  318.  
  319.  
  320.  
  321. class JulianTests(unittest.TestCase):
  322.     '''Test a _strptime regression that all julian (1-366) are accepted'''
  323.     
  324.     def test_all_julian_days(self):
  325.         eq = self.assertEqual
  326.         for i in range(1, 367):
  327.             eq(_strptime.strptime('%d 2004' % i, '%j %Y')[7], i)
  328.         
  329.  
  330.  
  331.  
  332. class CalculationTests(unittest.TestCase):
  333.     '''Test that strptime() fills in missing info correctly'''
  334.     
  335.     def setUp(self):
  336.         self.time_tuple = time.gmtime()
  337.  
  338.     
  339.     def test_julian_calculation(self):
  340.         format_string = '%Y %m %d %H %M %S %w %Z'
  341.         result = _strptime.strptime(time.strftime(format_string, self.time_tuple), format_string)
  342.         self.failUnless(result.tm_yday == self.time_tuple.tm_yday, 'Calculation of tm_yday failed; %s != %s' % (result.tm_yday, self.time_tuple.tm_yday))
  343.  
  344.     
  345.     def test_gregorian_calculation(self):
  346.         format_string = '%Y %H %M %S %w %j %Z'
  347.         result = _strptime.strptime(time.strftime(format_string, self.time_tuple), format_string)
  348.         if result.tm_year == self.time_tuple.tm_year and result.tm_mon == self.time_tuple.tm_mon:
  349.             pass
  350.         self.failUnless(result.tm_mday == self.time_tuple.tm_mday, 'Calculation of Gregorian date failed;%s-%s-%s != %s-%s-%s' % (result.tm_year, result.tm_mon, result.tm_mday, self.time_tuple.tm_year, self.time_tuple.tm_mon, self.time_tuple.tm_mday))
  351.  
  352.     
  353.     def test_day_of_week_calculation(self):
  354.         format_string = '%Y %m %d %H %S %j %Z'
  355.         result = _strptime.strptime(time.strftime(format_string, self.time_tuple), format_string)
  356.         self.failUnless(result.tm_wday == self.time_tuple.tm_wday, 'Calculation of day of the week failed;%s != %s' % (result.tm_wday, self.time_tuple.tm_wday))
  357.  
  358.     
  359.     def test_week_of_year_and_day_of_week_calculation(self):
  360.         
  361.         def test_helper(ymd_tuple, test_reason):
  362.             for directive in ('W', 'U'):
  363.                 format_string = '%%Y %%%s %%w' % directive
  364.                 dt_date = datetime_date(*ymd_tuple)
  365.                 strp_input = dt_date.strftime(format_string)
  366.                 strp_output = _strptime.strptime(strp_input, format_string)
  367.                 self.failUnless(strp_output[:3] == ymd_tuple, "%s(%s) test failed w/ '%s': %s != %s (%s != %s)" % (test_reason, directive, strp_input, strp_output[:3], ymd_tuple, strp_output[7], dt_date.timetuple()[7]))
  368.             
  369.  
  370.         test_helper((1901, 1, 3), 'week 0')
  371.         test_helper((1901, 1, 8), 'common case')
  372.         test_helper((1901, 1, 13), 'day on Sunday')
  373.         test_helper((1901, 1, 14), 'day on Monday')
  374.         test_helper((1905, 1, 1), 'Jan 1 on Sunday')
  375.         test_helper((1906, 1, 1), 'Jan 1 on Monday')
  376.         test_helper((1906, 1, 7), 'first Sunday in a year starting on Monday')
  377.         test_helper((1905, 12, 31), 'Dec 31 on Sunday')
  378.         test_helper((1906, 12, 31), 'Dec 31 on Monday')
  379.         test_helper((2008, 12, 29), 'Monday in the last week of the year')
  380.         test_helper((2008, 12, 22), 'Monday in the second-to-last week of the year')
  381.         test_helper((1978, 10, 23), 'randomly chosen date')
  382.         test_helper((2004, 12, 18), 'randomly chosen date')
  383.         test_helper((1978, 10, 23), 'year starting and ending on Monday while date not on Sunday or Monday')
  384.         test_helper((1917, 12, 17), 'year starting and ending on Monday with a Monday not at the beginning or end of the year')
  385.         test_helper((1917, 12, 31), 'Dec 31 on Monday with year starting and ending on Monday')
  386.  
  387.  
  388.  
  389. class CacheTests(unittest.TestCase):
  390.     '''Test that caching works properly.'''
  391.     
  392.     def test_time_re_recreation(self):
  393.         _strptime.strptime('10', '%d')
  394.         _strptime.strptime('2005', '%Y')
  395.         _strptime._TimeRE_cache.locale_time.lang = 'Ni'
  396.         original_time_re = id(_strptime._TimeRE_cache)
  397.         _strptime.strptime('10', '%d')
  398.         self.failIfEqual(original_time_re, id(_strptime._TimeRE_cache))
  399.         self.failUnlessEqual(len(_strptime._regex_cache), 1)
  400.  
  401.     
  402.     def test_regex_cleanup(self):
  403.         
  404.         try:
  405.             del _strptime._regex_cache['%d']
  406.         except KeyError:
  407.             pass
  408.  
  409.         bogus_key = 0
  410.         while len(_strptime._regex_cache) <= _strptime._CACHE_MAX_SIZE:
  411.             _strptime._regex_cache[bogus_key] = None
  412.             bogus_key += 1
  413.         _strptime.strptime('10', '%d')
  414.         self.failUnlessEqual(len(_strptime._regex_cache), 1)
  415.  
  416.     
  417.     def test_new_localetime(self):
  418.         locale_time_id = id(_strptime._TimeRE_cache.locale_time)
  419.         _strptime._TimeRE_cache.locale_time.lang = 'Ni'
  420.         _strptime.strptime('10', '%d')
  421.         self.failIfEqual(locale_time_id, id(_strptime._TimeRE_cache.locale_time))
  422.  
  423.  
  424.  
  425. def test_main():
  426.     test_support.run_unittest(getlang_Tests, LocaleTime_Tests, TimeRETests, StrptimeTests, Strptime12AMPMTests, JulianTests, CalculationTests, CacheTests)
  427.  
  428. if __name__ == '__main__':
  429.     test_main()
  430.  
  431.